let mongoHelper=require('../helper/mongodbHelper')
let dedupe=require('dedupe')
let col=null

mongoHelper.client.connect('mongodb://localhost:27017/data-analysis',(err,db)=>{
    if(err) throw err
    col=db.db('data-analysis').collection('enterprise-info')
})

class enterpriseController{

    //api/enterprise/enterpriseBaseInfo
    //获取基本信息接口
    static async enterpriseBaseInfo(ctx,next){
        ctx.body=await new Promise((resolve,reject)=>{
            col.find({}).sort({'时间范围':-1}).project({
                '_id':true,
                'name':true,
                "关键词":true,
                "谷歌纬度":true,
                "谷歌经度":true
            }).toArray((err,result)=>{
                if(err) reject(err)
                let map={}
                let arr=dedupe(result,value=>value.name)
                for(let obj of arr){
                    map[obj._id]=obj
                }
                resolve(map)
            })
            //col.find({}).project({'行业类别':true}).toArray((err,result)=>console.log(dedupe(result,value=>value['行业类别'])))
        })
    }
    //api/enterprise/singleEnterprise
    //根据单个企业信息接口，根据企业名称查询
    static async singleEnterprise(ctx,next){
        let query=ctx.request.query
        ctx.body=await new Promise((resolve,reject)=>{
            if(Object.getOwnPropertyNames(query).length===0){
                resolve('参数错误')
            }
            col.find({'name':query.name}).toArray((err,result)=>{
                if(err) reject(err)
                resolve(result)
            })
        })
    }
    //api/enterprise/singleEnterpriseByID
    //根据单个企业信息接口，根据_id称查询
    static async singleEnterpriseByID(ctx,next){
        let query=ctx.request.query
        ctx.body=await new Promise((resolve,reject)=>{
            if(Object.getOwnPropertyNames(query).length===0){
                resolve('参数错误')
            }
            col.find({'_id':query._id}).toArray((err,result)=>{
                if(err) reject(err)
                resolve(result[0])
            })
        })
    }


    //api/enterprise/statistical
    //获取根据表里数据获得统计信息
    static async statistical(ctx,next){
        ctx.body=await new Promise((resolve,reject)=>{
            let response={
                '注册资本':0,
                '资产总计':0,
                '净资产':0,
                '纳税总额':0,
                '出口创汇总额':0
            }
            col.find({}).sort({
                '时间范围':-1
            }).project({
                'name':true,
                '注册资本':true,
                '资产总计':true,
                '净资产':true,
                '纳税总额':true,
                '出口创汇总额':true,
                '_id':false
            }).toArray((err,result)=>{
                if(err) reject(err)
                let arr=dedupe(result,value=>value.name)
                for(let obj of arr){
                    response['注册资本']+=isNaN(parseFloat(obj['注册资本']))?0:parseFloat(obj['注册资本'])
                    response['资产总计']+=isNaN(parseFloat(obj['资产总计']))?0:parseFloat(obj['资产总计'])
                    response['净资产']+=isNaN(parseFloat(obj['净资产']))?0:parseFloat(obj['净资产'])
                    response['纳税总额']+=isNaN(parseFloat(obj['纳税总额']))?0:parseFloat(obj['纳税总额'])
                    response['出口创汇总额']+=isNaN(parseFloat(obj['出口创汇总额']))?0:parseFloat(obj['出口创汇总额'])
                }
                response['注册资本']=response['注册资本'].toFixed(4)+'万元'
                response['资产总计']=response['资产总计'].toFixed(4)+'万元'
                response['净资产']=response['净资产'].toFixed(4)+'万元'
                response['纳税总额']=response['纳税总额'].toFixed(4)+'万元'
                response['出口创汇总额']=response['出口创汇总额'].toFixed(4)+'万美元'
                resolve(response)
            })

        })
    }

    //api/enterprise/queryByTag
    //（废弃）根据标签获取对应的企业列表
    static async queryByTag(ctx,next){
        let query=ctx.request.query
        ctx.body=await new Promise((resolve,reject)=>{
            if(Object.getOwnPropertyNames(query).length===0){
                resolve('参数错误')
            }
            let tag={}
            tag[query.tag]='是'
            col.find(tag).toArray((err,result)=>{
                if(err) reject(err)
                resolve(dedupe(result,value=>value.name))
            })
        })
    }

    //api/enterprise/queryByBusiness
    //（废弃）根据行业类别获取对应的企业列表
    static async queryByBusiness(ctx,next){
        let query=ctx.request.query
        ctx.body=await new Promise((resolve,reject)=>{
            if(Object.getOwnPropertyNames(query).length===0){
                resolve('参数错误')
            }
            col.find({'行业类别':query.business}).toArray((err,result)=>{
                if(err) reject(err)
                resolve(dedupe(result,value=>value.name))
            })
        })
    } 
    //api/enterprise/heatmapInfo
    //获取热力图坐标信息(参数:statistical选定数值名称)
    static async heatmapInfo(ctx,next){
        let query=ctx.request.query
        ctx.body=await new Promise((resolve,reject)=>{
            let field={
                'name':true,
                '谷歌纬度':true,
                '谷歌经度':true
            }
            field[query.statistical]=true
            col.find({}).sort({'时间范围':-1}).project(field).toArray((err,result)=>{
                if(err) reject(err)
                let arr=dedupe(result,value=>value.name)
                let heatMap={}
                for(let i=0;i< arr.length;i++){
                    let obj=arr[i]
                    heatMap[obj['_id']]={
                        'lng':obj['谷歌经度'],
                        'lat':obj['谷歌纬度'],
                        'count':isNaN(parseFloat(obj[query.statistical]))?0:parseFloat(obj[query.statistical]),
                    }
                }
                resolve(heatMap)
            })
        })
    }
    //api/enterprise/queryIDByBusiness
    //根据行业分类获取对应数据集
    static async queryIDByBusiness(ctx){
        let data=ctx.request.query['business[]']
        ctx.body=await new Promise((resolve,reject)=>{
            if(!data){
                resolve('参数错误')
            }
            let query=[]
            if(!Array.isArray(data)){
                query.push({'行业类别':data})
            }else{
                for(let business of data){
                    query.push({'行业类别':business})
                }
            }

            col.find({$or:query}).sort({'时间范围':-1}).project({
                '_id':true,
                'name':true,
                '行业类别':true
            }).toArray((err,result)=>{
                if(err) reject(err)
                let arr=dedupe(result,value=>value.name)
                let map={}
                for(let obj of arr){
                    map[obj._id]=obj
                }
                resolve(map)
            })
        })
    }
    //api/enterprise/queryIDByEnterpriseTag
    //根据企业标签来获取对应数据集
    static async queryIDByEnterpriseTag(ctx){
        let data=ctx.request.query['enterpriseTag[]']
        ctx.body=await new Promise((resolve,reject)=>{
            if(!data){
                resolve('参数错误')
            }
            let query=[]
            if(!Array.isArray(data)){
                let obj={}
                obj[data]='是'
                query.push(obj)
            }else{
                if(data.indexOf('无标签')!==-1){
                    data.splice(data.indexOf('无标签'),1)
                    let pobj={}
                    for(let tag of data){
                        pobj[tag]='否'
                    }
                    query.push(pobj)
                }
                for(let tag of data){
                    let obj={}
                    obj[tag]='是'
                    query.push(obj)
                }
            }

            col.find({$or:query}).sort({'时间范围':-1}).project({
                '_id':true,
                'name':true
            }).toArray((err,result)=>{
                if(err) reject(err)
                let arr=dedupe(result,value=>value.name)
                let map={}
                for(let obj of arr){
                    map[obj._id]=obj
                }
                resolve(map)
            })
        })
    }
    //api/enterprise/queryByRegional
    //根据企业地区来获取对应数据集
    static async queryByRegional(ctx){
        let data=ctx.request.body
        ctx.body=await new Promise((resolve,reject)=>{
            if(!data){
                resolve('参数错误')
            }
            let query=[]
            for(let gov of data){
                query.push({
                    'gov':gov
                })
            }
            col.find({$or:query}).sort({'时间范围':-1}).project({
                '_id':true,
                'name':true,
                'gov':true
            }).toArray((err,result)=>{
                if(err) reject(err)
                let arr=dedupe(result,value=>value.name)
                let map={}
                for(let obj of arr){
                    map[obj._id]=obj
                }
                resolve(map)
            })
        })
    }
    //api/enterprise/queryByMultiple
    //多条件查询接口
    static async queryByMultiple(ctx){
        let data=ctx.request.body
        ctx.body=await new Promise((resolve,reject)=>{
            if(!data){
                resolve('参数错误')
            }
            //地区
            let queryGov=[]
            for(let gov of data.gov){
                queryGov.push({'gov':gov})
            }
            //行业
            let queryBusiness=[]
            for(let business of data.business){
                queryBusiness.push({'行业类别':business})
            }
            //标签
            let queryTag=[]
            if(data.enterpriseTag.indexOf('无标签')!==-1){
                data.enterpriseTag.splice(data.enterpriseTag.indexOf('无标签'),1)
                let pobj={}
                for(let tag of data.enterpriseTag){
                    pobj[tag]='否'
                }
                queryTag.push(pobj)
            }
            for(let tag of data.enterpriseTag){
                let obj={}
                obj[tag]='是'
                queryTag.push(obj)
            }
            // for(let tag of data.enterpriseTag){
            //     let obj={}
            //     obj[tag]='是'
            //     queryTag.push(obj)
            // }
            if(queryGov.length===0||queryBusiness.length===0||queryTag.length===0){
                resolve({})
                return
            }
            let query={
                $and:[
                    queryGov.length>0?{$or:queryGov}:{},
                    queryBusiness.length>0?{$or:queryBusiness}:{},
                    queryTag.length>0?{$or:queryTag}:{}
                ]
            }
            col.find(query).sort({'时间范围':-1}).project({
                '_id':true,
                'name':true,
                'gov':true,
                '行业类别':true
            }).toArray((err,result)=>{
                if(err) reject(err)
                if(result===null){
                    resolve({})
                    return
                }
                let arr=dedupe(result,value=>value.name)
                let map={}
                for(let obj of arr){
                    map[obj._id]=obj
                }
                resolve(map)
            })
        })
    }



////////////////////////////////////////////////////////////////
//测试用接口
////////////////////////////////////////////////////////////////
    //手动划分企业的行政区域分类
    static async uploadGov(ctx){
        let data=ctx.request.body.data
        let gov=ctx.request.body.gov
        ctx.body=await new Promise((resolve,reject)=>{
            for(let name of data){
                col.updateMany({name:name},{$set:{gov:gov}},{upsert: true},(err,res)=>{
                    if(err) throw err
                })
            }
            resolve('success')
        })
    }

}

module.exports=enterpriseController